//package com.pine.dcts.service;
//
//import io.netty.util.concurrent.Promise;
//
//import java.util.function.Function;
//
///**
// * @author xiaoyuan
// * @create 2021/1/15
// **/
//public interface Future<T> extends AsyncResult<T>, Handler<AsyncResult<T>> {
//
//    FutureFactory factory = (FutureFactory)ServiceHelper.loadFactory(FutureFactory.class);
//
//    static <T> Future<T> future(Handler<Promise<T>> handler) {
//        Promise promise = Promise.promise();
//
//        try {
//            handler.handle(promise);
//        } catch (Throwable var3) {
//            promise.tryFail(var3);
//        }
//
//        return promise.future();
//    }
//
//    /** @deprecated */
//    @Deprecated
//    static <T> Future<T> future() {
//        return factory.future();
//    }
//
//    static <T> Future<T> succeededFuture() {
//        return factory.succeededFuture();
//    }
//
//    static <T> Future<T> succeededFuture(T result) {
//        return result == null ? factory.succeededFuture() : factory.succeededFuture(result);
//    }
//
//    static <T> Future<T> failedFuture(Throwable t) {
//        return factory.failedFuture(t);
//    }
//
//    static <T> Future<T> failedFuture(String failureMessage) {
//        return factory.failureFuture(failureMessage);
//    }
//
//    boolean isComplete();
//
//    /** @deprecated */
//    @Deprecated
//    @Fluent
//    default Future<T> setHandler(Handler<AsyncResult<T>> handler) {
//        return this.onComplete(handler);
//    }
//
//    @Fluent
//    Future<T> onComplete(Handler<AsyncResult<T>> var1);
//
//    @Fluent
//    default Future<T> onSuccess(Handler<T> handler) {
//        return this.onComplete((ar) -> {
//            if (ar.succeeded()) {
//                handler.handle(ar.result());
//            }
//
//        });
//    }
//
//    @Fluent
//    default Future<T> onFailure(Handler<Throwable> handler) {
//        return this.onComplete((ar) -> {
//            if (ar.failed()) {
//                handler.handle(ar.cause());
//            }
//
//        });
//    }
//
//    /** @deprecated */
//    @Deprecated
//    void complete(T var1);
//
//    /** @deprecated */
//    @Deprecated
//    void complete();
//
//    /** @deprecated */
//    @Deprecated
//    void fail(Throwable var1);
//
//    /** @deprecated */
//    @Deprecated
//    void fail(String var1);
//
//    /** @deprecated */
//    @Deprecated
//    boolean tryComplete(T var1);
//
//    /** @deprecated */
//    @Deprecated
//    boolean tryComplete();
//
//    /** @deprecated */
//    @Deprecated
//    boolean tryFail(Throwable var1);
//
//    /** @deprecated */
//    @Deprecated
//    boolean tryFail(String var1);
//
//    T result();
//
//    Throwable cause();
//
//    boolean succeeded();
//
//    boolean failed();
//
//    default <U> Future<U> flatMap(Function<T, Future<U>> mapper) {
//        return this.compose(mapper);
//    }
//
//    /** @deprecated */
//
//    default <U> Future<U> compose(Handler<T> handler, Future<U> next) {
//        this.onComplete((ar) -> {
//            if (ar.succeeded()) {
//                try {
//                    handler.handle(ar.result());
//                } catch (Throwable var4) {
//                    if (next.isComplete()) {
//                        throw var4;
//                    }
//
//                    next.fail(var4);
//                }
//            } else {
//                next.fail(ar.cause());
//            }
//
//        });
//        return next;
//    }
//
//    default <U> Future<U> compose(Function<T, Future<U>> mapper) {
//        return this.compose(mapper, Future::failedFuture);
//    }
//
//    default <U> Future<U> compose(Function<T, Future<U>> successMapper, Function<Throwable, Future<U>> failureMapper) {
//        if (successMapper == null) {
//            throw new NullPointerException();
//        } else if (failureMapper == null) {
//            throw new NullPointerException();
//        } else {
//            Promise<U> ret = Promise.promise();
//            this.onComplete((ar) -> {
//                Future apply;
//                if (ar.succeeded()) {
//                    try {
//                        apply = (Future)successMapper.apply(ar.result());
//                    } catch (Throwable var7) {
//                        ret.fail(var7);
//                        return;
//                    }
//
//                    apply.onComplete(ret);
//                } else {
//                    try {
//                        apply = (Future)failureMapper.apply(ar.cause());
//                    } catch (Throwable var6) {
//                        ret.fail(var6);
//                        return;
//                    }
//
//                    apply.onComplete(ret);
//                }
//
//            });
//            return ret.future();
//        }
//    }
//
//    default <U> Future<U> map(Function<T, U> mapper) {
//        if (mapper == null) {
//            throw new NullPointerException();
//        } else {
//            Promise<U> ret = Promise.promise();
//            this.onComplete((ar) -> {
//                if (ar.succeeded()) {
//                    Object mapped;
//                    try {
//                        mapped = mapper.apply(ar.result());
//                    } catch (Throwable var5) {
//                        ret.fail(var5);
//                        return;
//                    }
//
//                    ret.complete(mapped);
//                } else {
//                    ret.fail(ar.cause());
//                }
//
//            });
//            return ret.future();
//        }
//    }
//
//    default <V> Future<V> map(V value) {
//        Promise<V> ret = Promise.promise();
//        this.onComplete((ar) -> {
//            if (ar.succeeded()) {
//                ret.complete(value);
//            } else {
//                ret.fail(ar.cause());
//            }
//
//        });
//        return ret.future();
//    }
//
//    default <V> Future<V> mapEmpty() {
//        return (Future)super.mapEmpty();
//    }
//
//    @GenIgnore
//    void handle(AsyncResult<T> var1);
//
//    /** @deprecated */
//    @Deprecated
//    @CacheReturn
//    default Handler<AsyncResult<T>> completer() {
//        return this;
//    }
//
//    default Future<T> recover(Function<Throwable, Future<T>> mapper) {
//        if (mapper == null) {
//            throw new NullPointerException();
//        } else {
//            Promise<T> ret = Promise.promise();
//            this.onComplete((ar) -> {
//                if (ar.succeeded()) {
//                    ret.complete(this.result());
//                } else {
//                    Future mapped;
//                    try {
//                        mapped = (Future)mapper.apply(ar.cause());
//                    } catch (Throwable var6) {
//                        ret.fail(var6);
//                        return;
//                    }
//
//                    mapped.onComplete(ret);
//                }
//
//            });
//            return ret.future();
//        }
//    }
//
//    default Future<T> otherwise(Function<Throwable, T> mapper) {
//        if (mapper == null) {
//            throw new NullPointerException();
//        } else {
//            Promise<T> ret = Promise.promise();
//            this.onComplete((ar) -> {
//                if (ar.succeeded()) {
//                    ret.complete(this.result());
//                } else {
//                    Object value;
//                    try {
//                        value = mapper.apply(ar.cause());
//                    } catch (Throwable var6) {
//                        ret.fail(var6);
//                        return;
//                    }
//
//                    ret.complete(value);
//                }
//
//            });
//            return ret.future();
//        }
//    }
//
//    default Future<T> otherwise(T value) {
//        Promise<T> ret = Promise.promise();
//        this.onComplete((ar) -> {
//            if (ar.succeeded()) {
//                ret.complete(this.result());
//            } else {
//                ret.complete(value);
//            }
//
//        });
//        return ret.future();
//    }
//
//    default Future<T> otherwiseEmpty() {
//        return (Future)super.otherwiseEmpty();
//    }
//}
